import java.util.Arrays;
import java.util.Scanner;

public class test {
    //递归求解汉诺塔问题
    public static void move(char x1,char x3){
        System.out.print("将"+x1+"->"+x3+" ");
    }

    /**
     *
     * @param a 输入数
     * @param x1 起点
     * @param x2 中转
     * @param x3 目的地
     */
    public static void hanoi(int a,char x1,char x2,char x3){
        if (a == 1) {
            move(x1,x3);
            return;
        }
        hanoi(a-1,x1,x3,x2);//将a-1个挪至 中转站
        move(x1,x3);
        hanoi(a-1,x2,x1,x3);
    }
    public static void main1(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入有多少数");
        int a = scanner.nextInt();
        char x1 ='A' ;
        char x2 ='B' ;
        char x3 ='C' ;
        hanoi(a,x1,x2,x3);
    }
    //实现一个方法 transform, 以数组为参数, 循环将数组中的每个元素 乘以 2 ,
    // 并设置到对应的数组元素上. 例如 原数组为 {1, 2, 3}, 修改之后为 {2, 4, 6}
   /* public  static  void  transform(int [] a){
        for (int i = 0; i < a.length; i++) {
            a[i]=a[i]*2;
        }
    }
    public static void main(String[] args) {
        int [] a ={1,2,3};
        transform(a);
        System.out.println(Arrays.toString(a));
    }*/
    //调整数组顺序使得奇数位于偶数之前。调整之后，不关心大小顺序。
    //如数组：[1,2,3,4,5,6]
    //调整后可能是：[1, 5, 3, 4, 2, 6]
   /* public  static  void odnum(int [] a){
        int x = 0;
        int y = a.length-1;
        int tep = 0 ;
        while(x<y){
            if(a[x]%2==0){
                if(a[y]%2!=0){
                    //当x为偶数，y为奇数，交换，让奇数在前偶数在后
                    tep = a[x];
                    a[x] = a[y];
                    a[y] = tep;
                }
                else {
                    y--;//a[y]为偶数时--
                }
            }
            else {
                x++;//a[x]为奇数时++
            }
        }
    }

    public static void main(String[] args) {
        int [] a = {1,2,3,4,5,6};
        odnum(a);
        System.out.println(Arrays.toString(a));
    }*/
    //给定一个有序整型数组, 实现二分查找
    /*public  static  int two(int []a,int n){
        int x = 0;
        int y = a.length-1;
        while (x <= y){
            int mid = (x+y)/2;
            if(a[mid]<n){
                x= mid+1;
            } else if (a[mid]==n) {
                return mid;
            }else if (a[mid]>n){
                y=mid -1;
            }
        }
        return -1;
    }

    public static void main(String[] args) {
        int [] a = {1,2,3,4,5,6};
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入要查找的下标");
        int n = scanner.nextInt();;
        if (two( a,n)==-1) {
            System.out.println("未找到");
        }else {
            System.out.println("下标为"+two( a,n));
        }
        scanner.close();
    }*/

    //给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。
    //你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。
    //你可以按任意顺序返回答案。
    //示例 1：
    //输入：nums = [2,7,11,15], target = 9
    //输出：[0,1]
    //解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。
   /* public static void main(String[] args) {
        int [] nums = {2,7,11,15};
        System.out.println(Arrays.toString(add(nums, 9)));
        System.out.println(Arrays.toString(add(nums, 26)));
        System.out.println(Arrays.toString(add(nums, 50)));
    }
    public  static  int[] add(int [] nums,int target){
        int [] a ={-1,-1};
        for (int i = 0; i < nums.length; i++) {
            for (int j = i+1; j < nums.length ; j++) {
                if (nums[i]+nums[j]==target) {
                    a [0] = i;
                    a [1] = j;
                }
            }
        }
        return  a;
    }*/
    //给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。
    /*public static void main(String[] args) {
        int [] a = {1,1,2,2,3,4,4,5,5};
        int [] b = {1,1,2,2,4,9,4,5,5};
        int [] c = {1,1,2,7,2,4,4,5,5};
        System.out.println(dog(a));
        System.out.println(dog(b));
        System.out.println(dog(c));
    }
    public  static  int dog (int [] a){
        int n = 0;
        for (int i = 0; i < a.length; i++) {
            n=n^a[i];
        }
        return n;
    }*/
    //给定一个大小为 n 的数组，找到其中的多数元素。多数元素是指在数组中出现次数 大于 ⌊ n/2 ⌋ 的元素。
    //你可以假设数组是非空的，并且给定的数组总是存在多数元素。
   /* public static void main(String[] args) {
        int [] a ={2,2,1,1,1,2,2};
        int [] b ={3,2,3};
        System.out.println(mo(a));
        System.out.println(mo(b));
    }
    public  static  int mo(int [] a){
        Arrays.sort(a);
        return a[a.length/2];
    }*/
    //给你一个整数数组 arr，请你判断数组中是否存在连续三个元素都是奇数的情况：如果存在，请返回 true ；否则，返回 false 。
    public static void main(String[] args) {
        int [] a ={2,6,4,1};
        int [] b ={1,2,34,3,4,5,7,23,12};
        System.out.println(con(a));
        System.out.println(con(b));
    }
    public static  boolean con (int [] a){
        for (int i = 0; i <a.length-2 ; i++) {
            if (a[i]%2 != 0) {
                if (a[i+1]%2 != 0){
                    if (a[i+2]%2 != 0){
                        return true;
                    }
                }
            }
        }
        return false;
    }
}
